home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / idlelib / run.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  11KB  |  365 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import sys
  5. import os
  6. import linecache
  7. import time
  8. import socket
  9. import traceback
  10. import thread
  11. import threading
  12. import Queue
  13. import CallTips
  14. import RemoteDebugger
  15. import RemoteObjectBrowser
  16. import StackViewer
  17. import rpc
  18. import __main__
  19. LOCALHOST = '127.0.0.1'
  20.  
  21. try:
  22.     import warnings
  23. except ImportError:
  24.     pass
  25.  
  26.  
  27. def idle_formatwarning_subproc(message, category, filename, lineno):
  28.     '''Format warnings the IDLE way'''
  29.     s = '\nWarning (from warnings module):\n'
  30.     s += '  File "%s", line %s\n' % (filename, lineno)
  31.     line = linecache.getline(filename, lineno).strip()
  32.     if line:
  33.         s += '    %s\n' % line
  34.     
  35.     s += '%s: %s\n' % (category.__name__, message)
  36.     return s
  37.  
  38. warnings.formatwarning = idle_formatwarning_subproc
  39. exit_now = False
  40. quitting = False
  41.  
  42. def main(del_exitfunc = False):
  43.     """Start the Python execution server in a subprocess
  44.  
  45.     In the Python subprocess, RPCServer is instantiated with handlerclass
  46.     MyHandler, which inherits register/unregister methods from RPCHandler via
  47.     the mix-in class SocketIO.
  48.  
  49.     When the RPCServer 'server' is instantiated, the TCPServer initialization
  50.     creates an instance of run.MyHandler and calls its handle() method.
  51.     handle() instantiates a run.Executive object, passing it a reference to the
  52.     MyHandler object.  That reference is saved as attribute rpchandler of the
  53.     Executive instance.  The Executive methods have access to the reference and
  54.     can pass it on to entities that they command
  55.     (e.g. RemoteDebugger.Debugger.start_debugger()).  The latter, in turn, can
  56.     call MyHandler(SocketIO) register/unregister methods via the reference to
  57.     register and unregister themselves.
  58.  
  59.     """
  60.     global no_exitfunc, exit_now
  61.     no_exitfunc = del_exitfunc
  62.     port = 8833
  63.     if sys.argv[1:]:
  64.         port = int(sys.argv[1])
  65.     
  66.     sys.argv[:] = [
  67.         '']
  68.     sockthread = threading.Thread(target = manage_socket, name = 'SockThread', args = ((LOCALHOST, port),))
  69.     sockthread.setDaemon(True)
  70.     sockthread.start()
  71.     while None:
  72.         
  73.         try:
  74.             if exit_now:
  75.                 
  76.                 try:
  77.                     exit()
  78.                 except KeyboardInterrupt:
  79.                     continue
  80.                 except:
  81.                     None<EXCEPTION MATCH>KeyboardInterrupt
  82.                 
  83.  
  84.             None<EXCEPTION MATCH>KeyboardInterrupt
  85.             
  86.             try:
  87.                 (seq, request) = rpc.request_queue.get(0)
  88.             except Queue.Empty:
  89.                 time.sleep(0.050000000000000003)
  90.                 continue
  91.  
  92.             (method, args, kwargs) = request
  93.             ret = method(*args, **kwargs)
  94.             rpc.response_queue.put((seq, ret))
  95.         continue
  96.         except KeyboardInterrupt:
  97.             if quitting:
  98.                 exit_now = True
  99.                 continue
  100.             continue
  101.             continue
  102.             except SystemExit:
  103.                 raise 
  104.                 continue
  105.                 (type, value, tb) = sys.exc_info()
  106.                 
  107.                 try:
  108.                     print_exception()
  109.                     rpc.response_queue.put((seq, None))
  110.                 continue
  111.                 traceback.print_exception(type, value, tb, file = sys.__stderr__)
  112.                 exit()
  113.  
  114.                 continue
  115.                 continue
  116.             
  117.             None<EXCEPTION MATCH>SystemExit
  118.         return None
  119.  
  120.  
  121.  
  122. def manage_socket(address):
  123.     global exit_now
  124.     for i in range(3):
  125.         time.sleep(i)
  126.         
  127.         try:
  128.             server = MyRPCServer(address, MyHandler)
  129.         continue
  130.         except socket.error:
  131.             err = None
  132.             print >>sys.__stderr__, 'IDLE Subprocess: socket error: ' + err[1] + ', retrying....'
  133.             continue
  134.         
  135.  
  136.     else:
  137.         print >>sys.__stderr__, 'IDLE Subprocess: Connection to IDLE GUI failed, exiting.'
  138.         exit_now = True
  139.         return None
  140.     server.handle_request()
  141.  
  142.  
  143. def show_socket_error(err, address):
  144.     import Tkinter as Tkinter
  145.     import tkMessageBox as tkMessageBox
  146.     root = Tkinter.Tk()
  147.     root.withdraw()
  148.     if err[0] == 61:
  149.         msg = "IDLE's subprocess can't connect to %s:%d.  This may be due to your personal firewall configuration.  It is safe to allow this internal connection because no data is visible on external ports." % address
  150.         tkMessageBox.showerror('IDLE Subprocess Error', msg, parent = root)
  151.     else:
  152.         tkMessageBox.showerror('IDLE Subprocess Error', 'Socket Error: %s' % err[1])
  153.     root.destroy()
  154.  
  155.  
  156. def print_exception():
  157.     import linecache
  158.     linecache.checkcache()
  159.     flush_stdout()
  160.     efile = sys.stderr
  161.     (typ, val, tb) = excinfo = sys.exc_info()
  162.     (sys.last_type, sys.last_value, sys.last_traceback) = excinfo
  163.     tbe = traceback.extract_tb(tb)
  164.     print >>efile, '\nTraceback (most recent call last):'
  165.     exclude = ('run.py', 'rpc.py', 'threading.py', 'Queue.py', 'RemoteDebugger.py', 'bdb.py')
  166.     cleanup_traceback(tbe, exclude)
  167.     traceback.print_list(tbe, file = efile)
  168.     lines = traceback.format_exception_only(typ, val)
  169.     for line in lines:
  170.         print >>efile, line,
  171.     
  172.  
  173.  
  174. def cleanup_traceback(tb, exclude):
  175.     '''Remove excluded traces from beginning/end of tb; get cached lines'''
  176.     orig_tb = tb[:]
  177.     while tb:
  178.         for rpcfile in exclude:
  179.             if tb[0][0].count(rpcfile):
  180.                 break
  181.                 continue
  182.         else:
  183.             break
  184.         del tb[0]
  185.     while tb:
  186.         for rpcfile in exclude:
  187.             if tb[-1][0].count(rpcfile):
  188.                 break
  189.                 continue
  190.         else:
  191.             break
  192.         del tb[-1]
  193.     if len(tb) == 0:
  194.         tb[:] = orig_tb[:]
  195.         print >>sys.stderr, '** IDLE Internal Exception: '
  196.     
  197.     rpchandler = rpc.objecttable['exec'].rpchandler
  198.     for i in range(len(tb)):
  199.         (fn, ln, nm, line) = tb[i]
  200.         if nm == '?':
  201.             nm = '-toplevel-'
  202.         
  203.         if not line and fn.startswith('<pyshell#'):
  204.             line = rpchandler.remotecall('linecache', 'getline', (fn, ln), { })
  205.         
  206.         tb[i] = (fn, ln, nm, line)
  207.     
  208.  
  209.  
  210. def flush_stdout():
  211.     
  212.     try:
  213.         if sys.stdout.softspace:
  214.             sys.stdout.softspace = 0
  215.             sys.stdout.write('\n')
  216.     except (AttributeError, EOFError):
  217.         pass
  218.  
  219.  
  220.  
  221. def exit():
  222.     """Exit subprocess, possibly after first deleting sys.exitfunc
  223.  
  224.     If config-main.cfg/.def 'General' 'delete-exitfunc' is True, then any
  225.     sys.exitfunc will be removed before exiting.  (VPython support)
  226.  
  227.     """
  228.     if no_exitfunc:
  229.         del sys.exitfunc
  230.     
  231.     sys.exit(0)
  232.  
  233.  
  234. class MyRPCServer(rpc.RPCServer):
  235.     
  236.     def handle_error(self, request, client_address):
  237.         '''Override RPCServer method for IDLE
  238.  
  239.         Interrupt the MainThread and exit server if link is dropped.
  240.  
  241.         '''
  242.         global exit_now, quitting
  243.         
  244.         try:
  245.             raise 
  246.         except SystemExit:
  247.             raise 
  248.         except EOFError:
  249.             exit_now = True
  250.             thread.interrupt_main()
  251.         except:
  252.             erf = sys.__stderr__
  253.             print >>erf, '\n' + '-' * 40
  254.             print >>erf, 'Unhandled server exception!'
  255.             print >>erf, 'Thread: %s' % threading.currentThread().getName()
  256.             print >>erf, 'Client Address: ', client_address
  257.             print >>erf, 'Request: ', repr(request)
  258.             traceback.print_exc(file = erf)
  259.             print >>erf, '\n*** Unrecoverable, server exiting!'
  260.             print >>erf, '-' * 40
  261.             quitting = True
  262.             thread.interrupt_main()
  263.  
  264.  
  265.  
  266.  
  267. class MyHandler(rpc.RPCHandler):
  268.     
  269.     def handle(self):
  270.         '''Override base method'''
  271.         executive = Executive(self)
  272.         self.register('exec', executive)
  273.         sys.stdin = self.console = self.get_remote_proxy('stdin')
  274.         sys.stdout = self.get_remote_proxy('stdout')
  275.         sys.stderr = self.get_remote_proxy('stderr')
  276.         import IOBinding as IOBinding
  277.         sys.stdin.encoding = sys.stdout.encoding = sys.stderr.encoding = IOBinding.encoding
  278.         self.interp = self.get_remote_proxy('interp')
  279.         rpc.RPCHandler.getresponse(self, myseq = None, wait = 0.050000000000000003)
  280.  
  281.     
  282.     def exithook(self):
  283.         '''override SocketIO method - wait for MainThread to shut us down'''
  284.         time.sleep(10)
  285.  
  286.     
  287.     def EOFhook(self):
  288.         '''Override SocketIO method - terminate wait on callback and exit thread'''
  289.         global quitting
  290.         quitting = True
  291.         thread.interrupt_main()
  292.  
  293.     
  294.     def decode_interrupthook(self):
  295.         '''interrupt awakened thread'''
  296.         global quitting
  297.         quitting = True
  298.         thread.interrupt_main()
  299.  
  300.  
  301.  
  302. class Executive:
  303.     
  304.     def __init__(self, rpchandler):
  305.         self.rpchandler = rpchandler
  306.         self.locals = __main__.__dict__
  307.         self.calltip = CallTips.CallTips()
  308.  
  309.     
  310.     def runcode(self, code):
  311.         
  312.         try:
  313.             self.usr_exc_info = None
  314.             exec code in self.locals
  315.         except:
  316.             self.usr_exc_info = sys.exc_info()
  317.             if quitting:
  318.                 exit()
  319.             
  320.             print_exception()
  321.             jit = self.rpchandler.console.getvar('<<toggle-jit-stack-viewer>>')
  322.             if jit:
  323.                 self.rpchandler.interp.open_remote_stack_viewer()
  324.             
  325.  
  326.         flush_stdout()
  327.  
  328.     
  329.     def interrupt_the_server(self):
  330.         thread.interrupt_main()
  331.  
  332.     
  333.     def start_the_debugger(self, gui_adap_oid):
  334.         return RemoteDebugger.start_debugger(self.rpchandler, gui_adap_oid)
  335.  
  336.     
  337.     def stop_the_debugger(self, idb_adap_oid):
  338.         '''Unregister the Idb Adapter.  Link objects and Idb then subject to GC'''
  339.         self.rpchandler.unregister(idb_adap_oid)
  340.  
  341.     
  342.     def get_the_calltip(self, name):
  343.         return self.calltip.fetch_tip(name)
  344.  
  345.     
  346.     def stackviewer(self, flist_oid = None):
  347.         if self.usr_exc_info:
  348.             (typ, val, tb) = self.usr_exc_info
  349.         else:
  350.             return None
  351.         flist = None
  352.         if flist_oid is not None:
  353.             flist = self.rpchandler.get_remote_proxy(flist_oid)
  354.         
  355.         while tb and tb.tb_frame.f_globals['__name__'] in [
  356.             'rpc',
  357.             'run']:
  358.             tb = tb.tb_next
  359.         sys.last_type = typ
  360.         sys.last_value = val
  361.         item = StackViewer.StackTreeItem(flist, tb)
  362.         return RemoteObjectBrowser.remote_object_tree_item(item)
  363.  
  364.  
  365.